home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / utilsys / rss14gmd.lha / RSys_1.4gmd / C / IntuiCtrl.c < prev    next >
C/C++ Source or Header  |  1996-05-04  |  19KB  |  856 lines
  1. /*
  2.    ***************************************************************************
  3.    *
  4.    * Datei:
  5.    *      RSysIntuiCtrl.c
  6.    *
  7.    * Inhalt:
  8.    *
  9.    *      --- Globale Routinen ---
  10.    *
  11.    *    APTR LockWindow ( WINDOW *win );
  12.    *    char *gadgetbuff ( GADGET *gad );
  13.    *    int OpenASysWindow ( int (*func )(void ), int kill );
  14.    *    long SetupScreen ( void );
  15.    *    SCREEN *FindFrontPubScr ( SCREEN *activescr );
  16.    *    void AdjustWindowDimensions ( SCREEN *Scr , UWORD WinLeftEdge , UWORD WinTopEdge , UWORD WinWidth , UWORD WinHeight , UWORD *NewWinLeftEdge , UWORD *NewWinTopEdge , UWORD *NewWinWidth , UWORD *NewWinHeight );
  17.    *    void CenterWindow ( SCREEN *scr , UWORD *top , UWORD *left , UWORD width , UWORD height );
  18.    *    void ClearIntuiMsgPort ( WINDOW *wnd );
  19.    *    void CloseASysWindow ( WINDOW **wind , GADGET **windgadlist , MENU **windmenus );
  20.    *    void CloseDownScreen ( void );
  21.    *    void DisableSysRequest ( int disable );
  22.    *    void EmptyListView ( void );
  23.    *    void EnableGadget ( WINDOW *Wnd , GADGET *gad , int on_off );
  24.    *    void InitListView ( WINDOW *wind , GADGET *gad , LIST *list , int top );
  25.    *    void LockMainWindow ( int on );
  26.    *    void makelabelvisible ( GADGET *gad );
  27.    *    void MakePattern ( WINDOW *wind );
  28.    *    void MakeWindowRefresh ( WINDOW *window );
  29.    *    void OpenMainWindow ( void );
  30.    *    void PrintHeader ( enum ListTypes type , char *text );
  31.    *    void PrintInfo ( char *text , int speakit , int waitit );
  32.    *    void PrintStatistics ( void );
  33.    *    void RefreshListView ( void );
  34.    *    void RefreshMainWindowPattern ( void );
  35.    *    void RefreshRastPort ( WINDOW *wind , GADGET **gads , int *gadnum , int cnt , int SaveGad , GADGET *GadgetList );
  36.    *    void RefreshWindowAndGadgets ( WINDOW *wind );
  37.    *    void UnlockWindow ( APTR req );
  38.    *    WORD MyEasyRequest ( WINDOW *wind , UBYTE *title , UBYTE *Gadgets , UBYTE *Body , ...);
  39.    *
  40.    *      --- Lokale  Routinen ---
  41.    *
  42.    *    static void FillGadget ( WINDOW *wind , GADGET *gad , BYTE SaveGad );
  43.    *
  44.    * Bemerkungen:
  45.    *      Intuition Supportroutinen für die Verwaltung der Intuitionobjekte
  46.    *      des Hauptwindows von RSys.
  47.    *      (Aus RSysUtils.c ausgelagert)
  48.    *
  49.    * Erstellungsdatum:
  50.    *      25-Jun-93     Rolf Böhme
  51.    *
  52.    * Änderungen:
  53.    *      25-Jun-93     Rolf Böhme        Erstellung
  54.    *      25-Jun-93     Rolf Böhme        makelabelvisible() hinzugefügt
  55.    *
  56.    ***************************************************************************
  57.  */
  58.  
  59. #include "RSys.h"
  60. #include "protos.h"
  61.  
  62. /********************************************************************
  63.  *                                                                  *
  64.  *       ***************** Gadget Routinen *****************        *
  65.  *                                                                  *
  66.  ********************************************************************/
  67.  
  68.  /*
  69.   * EnableGadget() schaltet ein Gadget auf einem Window ein oder
  70.   * aus
  71.   */
  72. void
  73. EnableGadget (WINDOW * Wnd, GADGET * gad, int on_off)
  74. {
  75.   DPOS;
  76.  
  77.   GT_SetGadgetAttrs (gad, Wnd, NULL, GA_Disabled, NOT (on_off), TAG_DONE);
  78.  
  79.   return;
  80. }
  81.  
  82. void
  83. makelabelvisible (GADGET * gad)
  84. {
  85.  
  86.   if (gad->GadgetText)
  87.     {
  88.       gad->GadgetText->DrawMode |= JAM2;
  89.       gad->GadgetText->BackPen = 0;
  90.       gad->GadgetText->FrontPen = 1;
  91.     }
  92.  
  93.   return;
  94. }
  95.  
  96.  /*
  97.   * gadgetbuff() ermittelt den String, der in einem Stringgadget
  98.   * steht
  99.   */
  100. char *
  101. gadgetbuff (GADGET * gad)
  102. {
  103.   DPOS;
  104.  
  105.   return ((char *) (((STRINGINFO *) (gad->SpecialInfo))->Buffer));
  106. }
  107.  
  108.  /*
  109.   * FillGadget() löscht den Hintergrund eines Boolean-Gadgets
  110.   */
  111. static void
  112. FillGadget (WINDOW * wind, GADGET * gad, BYTE SaveGad)
  113. {
  114.   BYTE GadType = (BYTE) gad->GadgetType;
  115.   UWORD pos;
  116.  
  117.   if (SaveGad)
  118.     pos = RemoveGadget (wind, gad);
  119.  
  120.   if (GadType == GTYP_STRGADGET)
  121.     EraseRect (wind->RPort, (long) gad->LeftEdge - 2,
  122.            (long) gad->TopEdge - 1,
  123.            (long) (gad->LeftEdge + gad->Width + 1),
  124.            (long) (gad->TopEdge + gad->Height));
  125.   else
  126.     EraseRect (wind->RPort, (long) gad->LeftEdge,
  127.            (long) gad->TopEdge,
  128.            (long) (gad->LeftEdge + gad->Width - 1),
  129.            (long) (gad->TopEdge + gad->Height - 1));
  130.  
  131.   if (SaveGad)
  132.     AddGadget (wind, gad, (ULONG) pos);
  133.  
  134.   return;
  135. }
  136.  
  137.  /*
  138.   * InitListView() initialisiert ein ListView in einem Fenster
  139.   * mit einer anzugebenden Liste. Ist die Liste NULL, wird das
  140.   * ListView systemgemäß mit ~0 initialisiert
  141.   */
  142. void
  143. InitListView (WINDOW * wind, GADGET * gad, LIST * list, int top)
  144. {
  145.   LIST *lvlist = (list != NULL) ? list : (LIST *) (~0);
  146.  
  147.   DPOS;
  148.  
  149.   if (list != NULL)
  150.     GT_SetGadgetAttrs (gad, wind, NULL, GTLV_Labels, (~0), TAG_DONE);
  151.  
  152.   if (top == UNSETLVPOS)
  153.     GT_SetGadgetAttrs (gad, wind, NULL, GTLV_Labels, lvlist, TAG_DONE);
  154.   else
  155.     GT_SetGadgetAttrs (gad, wind,
  156.                NULL,
  157.                GTLV_Labels, lvlist,
  158.                GTLV_Top, top,
  159.                GTLV_Selected, (~0),
  160.                TAG_DONE);
  161. }
  162.  
  163.  /*
  164.   * RefreshListView() erneuert das ListView auf dem Hauptwindow
  165.   */
  166. void
  167. RefreshListView (void)
  168. {
  169.   DPOS;
  170.  
  171.   InitListView (SysWnd, SysGadgets[GD_ListeLV], &ListeLVList, UNSETLVPOS);
  172.   return;
  173. }
  174.  
  175.  /*
  176.   * EmptyListView() löscht die Einträge des Haupt-ListViews
  177.   */
  178. void
  179. EmptyListView (void)
  180. {
  181.   DPOS;
  182.  
  183.   InitListView (SysWnd, SysGadgets[GD_ListeLV], NULL, 0);
  184.  
  185.   NewList (&ListeLVList);
  186.  
  187.   RefreshListView ();
  188.  
  189.   GT_RefreshWindow (SysWnd, NULL);
  190.  
  191.   return;
  192. }
  193.  
  194. /********************************************************************
  195.  *                                                                  *
  196.  *       ***************** Window Routinen *****************        *
  197.  *                                                                  *
  198.  ********************************************************************/
  199.  
  200.  /*
  201.   * LockWindow() öffnet einen Requester der Größe 1x1 und sperrt
  202.   * das Window damit gegen Eingaben
  203.   */
  204. APTR
  205. LockWindow (WINDOW * win)
  206. {
  207.   REQUESTER *req = NULL;
  208.  
  209.   DPOS;
  210.  
  211.   if (!win)
  212.     return NULL;
  213.  
  214.   req = (REQUESTER *) MyAllocVec (sizeof (REQUESTER), MEMF_ANY | MEMF_CLEAR, NO_KILL);
  215.   if (req)
  216.     {
  217.       req->LeftEdge = 1;
  218.       req->TopEdge = 1;
  219.       req->Width = 1;
  220.       req->Height = 1;
  221.       req->Flags = SIMPLEREQ | NOREQBACKFILL;
  222.  
  223.       Request (req, win);
  224.     }
  225.  
  226.   return ((APTR) req);
  227. }
  228.  
  229.  /*
  230.   * UnlockWindow() gibt ein mit LockWindow() gesperrtes Window
  231.   * wieder frei. Es ist dann wieder für Benutzereingaben
  232.   * zugänglich
  233.   */
  234. void
  235. UnlockWindow (APTR req)
  236. {
  237.   DPOS;
  238.  
  239.   if (req)
  240.     {
  241.       EndRequest ((REQUESTER *) req, ((REQUESTER *) req)->RWindow);
  242.       MyFreeVec (req);
  243.  
  244.       req = NULL;
  245.     }
  246.  
  247.   return;
  248. }
  249.  
  250. void
  251. LockMainWindow (int on)
  252. {
  253.   static APTR req = NULL;
  254.  
  255.   if (on)
  256.     req = LockWindow (SysWnd);
  257.   else
  258.     {
  259.       UnlockWindow (req);
  260.       RefreshMainWindowPattern ();
  261.       PrintStatistics ();
  262. /*      RefreshList(LastID); */
  263.     }
  264.  
  265.   return;
  266. }
  267.  
  268.  /*
  269.   * MakeWindowRefresh() führt die Standard-System-Routinen zur
  270.   * Erneuerung eines Windows aus
  271.   */
  272. void
  273. MakeWindowRefresh (WINDOW * window)
  274. {
  275.   GT_BeginRefresh (window);
  276.   GT_EndRefresh (window, TRUE);
  277.  
  278.   return;
  279. }
  280.  
  281. void
  282. MakePattern (WINDOW * wind)
  283. {
  284.   RASTPORT *RP = wind->RPort;
  285.  
  286.   if (wind != SysWnd && (wind->Flags & WFLG_ZOOMED))
  287.     return;
  288.  
  289.   if (bgc || bpc)
  290.     {
  291.       SetAfPt (RP, (USHORT *) & bpp, 1L);
  292.  
  293.       SetAPen (RP, bpc);
  294.       SetBPen (RP, bgc);
  295.  
  296.       SetDrMd (RP, JAM2);
  297.  
  298.       RectFill (RP, (long) OffX, (long) OffY,
  299.         (long) wind->Width - Scr->WBorRight,
  300.         (long) wind->Height - Scr->WBorBottom + 1 - wind->BorderBottom);
  301.  
  302.       SetAfPt (RP, NULL, NULL);
  303.     }
  304.   else
  305.     {
  306.       SetAPen (RP, 0);
  307.       SetBPen (RP, 0);
  308.  
  309.       RectFill (RP, (long) OffX, (long) OffY,
  310.         (long) wind->Width - Scr->WBorRight,
  311.         (long) wind->Height - Scr->WBorBottom + 1 - wind->BorderBottom);
  312.     }
  313.  
  314.   return;
  315. }
  316.  
  317. void
  318. RefreshWindowAndGadgets (WINDOW * wind)
  319. {
  320.   RefreshGadgets (wind->FirstGadget, wind, NULL);
  321.  
  322.   RefreshWindowFrame (wind);
  323.   GT_RefreshWindow (wind, NULL);
  324.  
  325.   return;
  326. }
  327.  
  328.  /*
  329.   * RefreshRastPort() malt das Hintergrundmuster und erneuert
  330.   * die Gadgets und deren Hintergrund
  331.   */
  332. void
  333. RefreshRastPort (WINDOW * wind, GADGET ** gads,
  334.          int *gadnum, int cnt, int SaveGad,
  335.          GADGET * GadgetList)
  336. {
  337.   GADGET *gad;
  338.   int i;
  339.  
  340.   if (wind != SysWnd && (wind->Flags & WFLG_ZOOMED))
  341.     return;
  342.  
  343.   MakePattern (wind);
  344.  
  345.   if (bgc || bpc)
  346.     {
  347.       for (i = 0; i < cnt; i++)
  348.     FillGadget (wind, gads[gadnum[i]], (BYTE) SaveGad);
  349.  
  350.       for (gad = gads[0]; gad; gad = gad->NextGadget)
  351.     if (gad->GadgetText)
  352.       {
  353.         int pixlen = IntuiTextLength (gad->GadgetText);
  354.         int x = gad->LeftEdge + gad->GadgetText->LeftEdge - 3, y = gad->TopEdge + gad->GadgetText->TopEdge - 2,
  355.           w = pixlen + 6, h = gad->GadgetText->ITextFont->ta_YSize + 4;
  356.  
  357.         EraseRect (wind->RPort, (long) x, (long) y, (long) (x + w - 1), (long) (y + h - 1));
  358.  
  359.         DrawBevelBox (wind->RPort, x, y, w, h,
  360.               GTBB_Recessed, TRUE,
  361.               GT_VisualInfo, VisualInfo,
  362.               TAG_DONE);
  363.       }
  364.     }
  365.  
  366.   if (GadgetList)
  367.     AddGList (wind, GadgetList, -1, -1, NULL);
  368.  
  369.   RefreshWindowAndGadgets (wind);
  370.  
  371.   if (Flags.autofront)
  372.     {
  373.       WindowToFront (wind);
  374.       ActivateWindow (wind);
  375.     }
  376.  
  377.   return;
  378. }
  379.  
  380.  /*
  381.   * RefreshMainWindowPattern() erneuert das Patternmuster
  382.   * des Hauptfensters von RSys
  383.   */
  384. void
  385. RefreshMainWindowPattern (void)
  386. {
  387.   int gl[] =
  388.   {GD_ListeLV, GD_TextHeader, GD_InfoMsgGad};
  389.  
  390.   if (SysWnd)
  391.     RefreshRastPort (SysWnd, SysGadgets, gl, 3, TRUE, NULL);
  392.  
  393.   return;
  394. }
  395.  
  396.  /*
  397.   * ClearIntuiMsgPort() beantwortet alle anliegenden Messages
  398.   * eines Windows
  399.   */
  400. void
  401. ClearIntuiMsgPort (WINDOW * wnd)
  402. {
  403.   INTUIMESSAGE *message;
  404.  
  405.   DPOS;
  406.  
  407.   while (message = (INTUIMESSAGE *) GT_GetIMsg (wnd->UserPort))
  408.     GT_ReplyIMsg (message);
  409.  
  410.   return;
  411. }
  412.  
  413.  /*
  414.   * OpenMainWindow() öffnet das Hauptffenster
  415.   */
  416. void
  417. OpenMainWindow (void)
  418. {
  419.   int OpenSysWindow (void);
  420.  
  421.   int err;
  422.  
  423.   DPOS;
  424.  
  425.   if (!(err = SetupScreen ()))
  426.     {
  427.       OpenASysWindow (OpenSysWindow, KILL);
  428.       return;
  429.     }
  430.  
  431.   if (err == 1)
  432.     ErrorHandle ((char *) namebuffer, SCREEN_ERR, LOCK_FAIL, KILL);
  433.   else
  434.     ErrorHandle ((char *) "Visual info", SCREEN_ERR, INFO_FAIL, KILL);
  435.  
  436.   return;
  437. }
  438.  
  439.  /*
  440.   * CloseASysWindow() schließt ein von RSys verwaltetes Window
  441.   */
  442. void
  443. CloseASysWindow (WINDOW ** wind, GADGET ** windgadlist, MENU ** windmenus)
  444. {
  445.   DPOS;
  446.  
  447.   if (!(*wind))
  448.     return;
  449.  
  450.   if (windmenus && *windmenus)
  451.     {
  452.       ClearMenuStrip (*wind);
  453.       FreeMenus (*windmenus);
  454.       *windmenus = NULL;
  455.     }
  456.  
  457.   if (wind && *wind)
  458.     {
  459.       CloseWindow (*wind);
  460.       *wind = NULL;
  461.     }
  462.  
  463.   if (windgadlist && *windgadlist)
  464.     {
  465.       FreeGadgets (*windgadlist);
  466.       *windgadlist = NULL;
  467.     }
  468.  
  469.   return;
  470. }
  471.  
  472.  /*
  473.   * OpenASysWindow() öffnet ein Window mit einer
  474.   * vorzugebenden Funktion und mit einer allgemeinen
  475.   * Fehlerbehandlung
  476.   */
  477. int
  478. OpenASysWindow (int (*func) (void), int kill)
  479. {
  480.   ULONG failed = (*func) ();
  481.  
  482.   DPOS;
  483.  
  484.   switch (failed)
  485.     {
  486.     case 1L:
  487.       ErrorHandle ("GadTools-Context", OBJECT_CONTEXT_ERR, CREATE_FAIL, kill);
  488.       break;
  489.  
  490.     case 2L:
  491.       ErrorHandle ("CreateGadget()", GADGET_ERR, CREATE_FAIL, kill);
  492.       break;
  493.  
  494.     case 3L:
  495.       ErrorHandle ("LayoutMenu()", MENU_ERR, CREATE_FAIL, kill);
  496.       break;
  497.  
  498.     case 4L:
  499.       ErrorHandle ("OpenWindowTags()", WINDOW_ERR, OPEN_FAIL, kill);
  500.       break;
  501.     }
  502.  
  503.   return (failed ? FALSE : TRUE);
  504. }
  505.  
  506.  /*
  507.   * CenterWindow() ermittelt die Fensterposition, um das
  508.   * Fenster zentriert auf einem Screen erscheinen zu lassen
  509.   */
  510. void
  511. CenterWindow (SCREEN * scr, UWORD * top, UWORD * left,
  512.           UWORD width, UWORD height)
  513. {
  514.   WORD LE, TE;
  515.   WORD restwidth = scr->Width - width, restheight = scr->Height - height;
  516.  
  517.   DPOS;
  518.  
  519.   if (scr)
  520.     {
  521.       LE = (Flags.mousewindow ? scr->MouseX : (scr->Width >> 1)) - (width >> 1);
  522.       TE = (Flags.mousewindow ? scr->MouseY : (scr->Height >> 1)) - (height >> 1);
  523.  
  524.       *left = (LE < 0) ? (UWORD) 0 : ((LE > restwidth) ? restwidth : LE);
  525.       *top = (TE < 0) ? (UWORD) 0 : ((TE > restheight) ? restheight : TE);
  526.     }
  527.  
  528.   return;
  529. }
  530.  
  531. void
  532. AdjustWindowDimensions (SCREEN * Scr,
  533.             UWORD WinLeftEdge, UWORD WinTopEdge,
  534.             UWORD WinWidth, UWORD WinHeight,
  535.             UWORD * NewWinLeftEdge, UWORD * NewWinTopEdge,
  536.             UWORD * NewWinWidth, UWORD * NewWinHeight)
  537. {
  538.   DPOS;
  539.  
  540.   ComputeFont (Scr, WinWidth, WinHeight);
  541.  
  542.   *NewWinWidth = compute ((UWORD) 0, FontX, (int) WinWidth);
  543.   *NewWinHeight = compute ((UWORD) 0, FontY, (int) WinHeight);
  544.  
  545.   if ((WinLeftEdge + *NewWinWidth + OffX + Scr->WBorRight) > Scr->Width)
  546.     *NewWinLeftEdge = Scr->Width - *NewWinWidth;
  547.  
  548.   if ((WinTopEdge + *NewWinHeight + OffY + Scr->WBorBottom) > Scr->Height)
  549.     *NewWinTopEdge = Scr->Height - *NewWinHeight;
  550.  
  551.   *NewWinWidth = compute ((UWORD) (OffX + Scr->WBorRight), FontX, (int) WinWidth);
  552.   *NewWinHeight = compute ((UWORD) (OffY + Scr->WBorBottom), FontY, (int) WinHeight);
  553.  
  554.   CenterWindow (Scr, NewWinTopEdge, NewWinLeftEdge, *NewWinWidth, *NewWinHeight);
  555.  
  556.   return;
  557. }
  558.  
  559.  
  560. /********************************************************************
  561.  *                                                                  *
  562.  *       ***************** Screen Routinen *****************        *
  563.  *                                                                  *
  564.  ********************************************************************/
  565.  
  566.  /*
  567.   * Die Funktion FindFrontPubScr() ermittelt
  568.   * bezüglich des aktuellen Screens, auf dem das
  569.   * Hauptfenster geöffnet wurde, den nächsten Public
  570.   * screen und gibt den Zeiger auf diesen zurück,
  571.   * falls dieser ungleich dem aktuellen und zugleich
  572.   * der vorderste Screen auf dem Bildschirm ist.
  573.   */
  574. SCREEN *
  575. FindFrontPubScr (SCREEN * activescr)
  576. {
  577.   char newnamebuffer[MAXPUBSCREENNAME + 1];
  578.   UBYTE *test;
  579.   SCREEN *NewScr;
  580.  
  581.   DPOS;
  582.   /*
  583.    * Der Name des aktuellen Screens, auf dem RSys
  584.    * geöffnet wurde, wird gemerkt.
  585.    */
  586.   strncpy (newnamebuffer, (char *) namebuffer, MAXPUBSCREENNAME);
  587.  
  588.   /*
  589.    * Der Zeiger des neuen Screens wird initialisiert
  590.    * und der nächst Public screen ermittelt.
  591.    */
  592.   NewScr = NULL;
  593.   test = NextPubScreen (activescr, namebuffer);
  594.  
  595.   /*
  596.    * Solange der neue Screen nicht der vorderste
  597.    * Screen und nicht der aktuelle ist, und der neue
  598.    * Screen erfolgreich ermittelt werden konnte, wird
  599.    * dieser neue getestet. Im Erfolgsfall wird ein
  600.    * Zeiger auf diesen neuen Screen zurückgegeben.
  601.    */
  602.   while ((NewScr != IntuitionBase->FirstScreen) && (NewScr != activescr) && test)
  603.     {
  604.       NewScr = LockPubScreen (namebuffer);
  605.  
  606.       if ((NewScr == IntuitionBase->FirstScreen) && (NewScr != activescr))
  607.     {
  608.       UnlockPubScreen (NULL, NewScr);
  609.       return (NewScr);
  610.     }
  611.  
  612.       UnlockPubScreen (NULL, NewScr);
  613.  
  614.       test = NextPubScreen (NewScr, namebuffer);
  615.     }
  616.  
  617.   /*
  618.    * Wenn das Unterprogramm bis hierher kommt, konnte
  619.    * kein weiterer Public screen erkannt werden. Der
  620.    * gemerkte Screen name wird zurückkopiert und der
  621.    * Zeiger auf den aktiven Screen zurückgegeben.
  622.    */
  623.   strncpy ((char *) namebuffer, newnamebuffer, MAXPUBSCREENNAME);
  624.  
  625.   return (activescr);
  626. }
  627.  
  628.  /*
  629.   * SetupScreen() ermittelt eine Zeiger auf den vordersten
  630.   * Screen. Ist der vorderste Screen kein PublicScreen,
  631.   * wird der WorkBench-Screen als Default-Screen genommen.
  632.   */
  633. long
  634. SetupScreen (void)
  635. {
  636.  
  637.   DPOS;
  638.  
  639.   (void) FindFrontPubScr (lastpubscreen);
  640.  
  641.   if (NOT (Scr = LockPubScreen (namebuffer)))
  642.     {
  643.       strcpy ((char *) namebuffer, "Workbench");
  644.       if (NOT (Scr = LockPubScreen (namebuffer)))
  645.     return (1L);
  646.     }
  647.  
  648.   ComputeFont (Scr, (UWORD) 0, (UWORD) 0);
  649.  
  650.   if (NOT (VisualInfo = GetVisualInfo (Scr, TAG_DONE)))
  651.     return (2L);
  652.  
  653.   lastpubscreen = Scr;
  654.  
  655.   return NULL;
  656. }
  657.  
  658.  /*
  659.   * CloseDownScreen() gibt den Screen frei, auf den ein
  660.   * RSys-Window geöffnet wurde.
  661.   */
  662. void
  663. CloseDownScreen (void)
  664. {
  665.   DPOS;
  666.  
  667.   if (VisualInfo)
  668.     {
  669.       FreeVisualInfo (VisualInfo);
  670.       VisualInfo = NULL;
  671.     }
  672.  
  673.   if (Scr)
  674.     {
  675.       UnlockPubScreen (NULL, Scr);
  676.       Scr = NULL;
  677.     }
  678.  
  679.   return;
  680. }
  681.  
  682.  
  683. /********************************************************************
  684.  *                                                                  *
  685.  *    ***************** Informations Routinen *****************     *
  686.  *                                                                  *
  687.  ********************************************************************/
  688.  
  689.  /*
  690.   * DisableSysRequest() unterdrückt die Anzeige von
  691.   * Systemrequestern, die beispielsweise nach einem Zugriff auf
  692.   * einen nicht existierenden Datenträger erscheinen
  693.   */
  694. void
  695. DisableSysRequest (int disable)
  696. {
  697.   static APTR wind;
  698.   PROCESS *p = (PROCESS *) FindTask (NULL);
  699.  
  700.   DPOS;
  701.  
  702.   if (disable)
  703.     {
  704.       wind = (APTR) p->pr_WindowPtr;
  705.       p->pr_WindowPtr = (APTR) (-1);
  706.     }
  707.   else
  708.     p->pr_WindowPtr = wind;
  709.  
  710.   return;
  711. }
  712.  
  713.  
  714.  
  715.  /*
  716.   * PrintHeader() gibt einen Text im Titelfeld über dem
  717.   * Haupt-ListView aus
  718.   */
  719. void
  720. PrintHeader (enum ListTypes type, char *text)
  721. {
  722.   DPOS;
  723.  
  724.   LastID = type;
  725.  
  726.   GT_SetGadgetAttrs (SysGadgets[GD_TextHeader], SysWnd,
  727.              NULL,
  728.        GTTX_Text, (UBYTE *) (NOT (text) ? EntryAttr[type].ea_header : text),
  729.              TAG_DONE);
  730.  
  731.   return;
  732. }
  733.  
  734.  /*
  735.   * PrintInfo() gibt einen Text im Messagefeld vom Hauptfenster
  736.   * aus. Falls der Sprachmodus aktiviert ist und der Text
  737.   * gesprochen werden soll, wird er zusätzlich auf dem
  738.   * Narrator-Device ausgegeben
  739.   */
  740. void
  741. PrintInfo (char *text, int speakit, int waitit)
  742. {
  743.   static char help[BUFSIZE];
  744.   int i, len = strlen (text), fill = ((BUFSIZE - len) >> 1);
  745.  
  746.   DPOS;
  747.  
  748.   if (!SysWnd || SysWnd->FirstRequest)
  749.     return;
  750.  
  751.   for (i = 0; i < fill; i++)
  752.     help[i] = ' ';
  753.  
  754.   help[fill] = STRINGEND;
  755.  
  756.   strcat (help, text);
  757.  
  758.   GT_SetGadgetAttrs (SysGadgets[GD_InfoMsgGad], SysWnd,
  759.              NULL,
  760.              GTTX_Text, (UBYTE *) help,
  761.              TAG_DONE);
  762.  
  763.   if (NOT (Flags.fastmode))
  764.     WaitTOF ();
  765.  
  766.   if (Flags.speakmode && speakit)
  767.     Speak (help);
  768.  
  769.   if (waitit != 0)
  770.     Delay (waitit);
  771.  
  772.   return;
  773. }
  774.  
  775.  /*
  776.   * PrintStatistics() gibt für bestimmte Listen eine
  777.   * Zusammenfasung (Anzahl der ermittelten Einträge) aus
  778.   */
  779.  
  780. /*
  781.  * hacked by GMD
  782.  */
  783.  
  784. void
  785. PrintStatistics (void)
  786. {
  787.   char help[BUFSIZE];
  788.   char *type = EntryAttr[LastID].ea_type;
  789.  
  790.   DPOS;
  791.  
  792.   help[0] = '\0';
  793.  
  794.   if (!SysWnd || SysWnd->FirstRequest)
  795.     return;
  796.  
  797.   if (countentries == 0)
  798.     {
  799.       sprintf (help, "No %s entries read", type);
  800.     }
  801.   else if (EntryAttr[LastID].ea_counted == EA_C)
  802.     {
  803.       sprintf (help, "%ld %s entries read", countentries, type);
  804.     }
  805.   else if (EntryAttr[LastID].ea_counted == EA_C_HELP)
  806.     {
  807.       strncpy (help, gbuf, BUFSIZE);
  808.       help[BUFSIZE - 1] = '\0';    /* just in sace */
  809.     }
  810. #if 0
  811.   else if (EntryAttr[LastID].ea_counted == EA_NOTC)
  812.     {
  813.       sprintf (help, "done");
  814.     }
  815. #endif
  816.  
  817.   PrintInfo (help, SPEAK, 0);
  818.  
  819.   RefreshListView ();
  820.  
  821.   return;
  822. }
  823.  
  824.  /*
  825.   * MyEasyRequest() erzeugt nach Vorgaben einen
  826.   * System-Standard-Requester
  827.   */
  828. WORD
  829. MyEasyRequest (WINDOW * wind, UBYTE * title,
  830.            UBYTE * Gadgets, UBYTE * Body,...)
  831. {
  832.   EASYSTRUCT Easy;
  833.   WORD Result;
  834.   va_list VarArgs;
  835.   APTR req;
  836.  
  837.   DPOS;
  838.  
  839.   Easy.es_StructSize = sizeof (EASYSTRUCT);
  840.  
  841.   Easy.es_Flags = NULL;
  842.   Easy.es_Title = title;
  843.   Easy.es_TextFormat = Body;
  844.   Easy.es_GadgetFormat = Gadgets;
  845.  
  846.   req = LockWindow (wind);
  847.  
  848.   va_start (VarArgs, Body);
  849.   Result = EasyRequestArgs (wind, &Easy, NULL, VarArgs);
  850.   va_end (VarArgs);
  851.  
  852.   UnlockWindow (req);
  853.  
  854.   return Result;
  855. }
  856.